---
title: Philosophy
description: LangChain exists to be the easiest place to start building with LLMs, while also being flexible and production-ready.
mode: wide
---

import AlphaCallout from '/snippets/alpha-lc-callout.mdx';

<AlphaCallout />

LangChain is driven by a few core beliefs:

- LLMs are great, powerful new technology.
- LLMs are even better when you combine them with external sources of data computation.
- LLMs will transform what the applications of the future look like. Specifically, the applications of the future will look more and more agentic.
- It is still very early on in that transformation.
- While it's easy to build a prototype of those agentic applications, it's still really hard to build agents that are reliable enough to put into production.

With LangChain, we have two core focuses:

<Steps>
<Step title="We want to make it possible for developers to build with whatever the best model is at the time.">

Different providers expose different APIs, with different model parameters and different message formats.
Standardizing these model inputs and outputs is a core focus, making it easy for developer to easily change to the most recent state-of-the-art model, avoiding lock-in.
</Step>
<Step title="We want to make it easy to use these models to orchestrate more complex flows that interact with other data and computation.">
Models should be used for more than just *calling* - they should also be used to orchestrate more complex flows that interact with other data and computation. LangChain makes it easy to define [tools](/oss/langchain/tools) that LLMs can use dynamically, as well as help with parsing of and access to unstructured data.
</Step>
</Steps>

## History

Given the constant rate of change in the field, LangChain has also evolved over time. Below is a brief timeline of how LangChain has changed over the years, evolving alongside what it means to build with LLMs:

<Card title="October 24, 2022: LangChain launched as a Python package" horizontal>
A month before ChatGPT, LangChain was launched as a Python package. It consisted of two main components:

- LLM abstractions
- "Chains", or predetermined steps of computation to run, for common use cases. For example - RAG: run a retrieval step, then run a generation step.

The name LangChain comes from "Language" (like Language models) and "Chains".
</Card>


<Card title="December 2022: The first general purpose agents were added to LangChain." horizontal>
These general purpose agents were based on the [ReAct paper](https://arxiv.org/abs/2210.03629) (ReAct standing for Reasoning and Acting). They used LLMs to generate JSON that represented tool calls, and then parsed that JSON to determine what tools to call.
</Card>


<Card title="January 2023: OpenAI releases a 'Chat Completion' API" horizontal>
Previously, models took in strings and returned a string. In the ChatCompletions API, they evolved to take in a list of messages and return a message. Other model providers followed suit, and LangChain updated to work with lists of messages.
</Card>

<Card title="January 2023: LangChain releases a JavaScript version" horizontal>
LLMs and agents will change how applications are built and JavaScript is the language of application developers.
</Card>

<Card title="February 2023: LangChain Inc. was formed as a company around the open source LangChain project" horizontal>
The main goal was to "make intelligent agents ubiquitous". The team recognized that while LangChain was a key part (LangChain made it simple to get started with LLMs), there was also a need for other components.
</Card>

<Card title="Spring 2023: OpenAI releases 'function calling' in their API" horizontal>
This allowed the API to explicitly generate payloads that represented tool calls. Other model providers followed suit, and LangChain was updated to use this as the preferred method for tool calling (rather than parsing JSON).
</Card>

<Card title="Summer 2023: LangSmith is released as closed source platform by LangChain Inc., providing observability and evals" horizontal>
The main issue with building agents is getting them to be reliable, and LangSmith, which provides observability and evals, was built to solve that need. LangChain was updated to integrate seamlessly with LangSmith.
</Card>

<Card title="January 2024: langchain releases 0.1, its first non-0.0.x" horizontal>
The industry matured from prototypes to production, and as such, LangChain increased its focus on stability.
</Card>

<Card title="February 2024: LangGraph is released as an open-source library" horizontal>
The original LangChain had two focuses: LLM abstractions, and high-level interfaces for getting started with common applications; however, it was missing a low-level orchestration layer that allowed developers to control the exact flow of their agent. Enter: LangGraph.

When building LangGraph, we learned from lessons when building LangChain and added functionality we discovered was needed: streaming, durable execution, short-term memory, human-in-the-loop, and more.
</Card>

<Card title="Summer 2024: LangChain has over 700 integrations" horizontal>
Integrations were split out of the core LangChain package, and either into their own standalone packages (for the core integrations) or `langchain-community` (for the long tail).
</Card>

<Card title="Fall 2024: LangGraph becomes the preferred way to build any AI applications that's more than a single LLM call" horizontal>
As developers tried to improve the reliability of their applications, they needed more control than the high-level interfaces provided. LangGraph provided that low-level flexibility. Most chains and agents were marked as deprecated in LangChain with guides on how to migrate them to LangGraph. There is still one high-level abstraction created in LangGraph: an agent abstraction. It is built on top of low-level LangGraph and has the same interface as the ReAct agents from LangChain.
</Card>

<Card title="Spring 2025: Model APIs become more multimodal" horizontal>
Models started to accept files, images, videos, and more. We updated the `langchain-core` message format accordingly to allow developers to specify these multimodal inputs in a standard way.
</Card>

{/*

<Card title="Fall 2025: LangChain releases 1.0 with two major changes" horizontal>

LangChain 1.0 contains two big changes:

1. Complete revamp of all chains and agents in `langchain`. All chains and agents are now replaced with only one high level abstraction: an agent abstraction built on top of LangGraph. This was the high-level abstraction that was originally created in LangGraph, but just moved to LangChain.

    For users still using old LangChain chains/agents who do NOT want to upgrade (note: we recommend you do), you can continue using old LangChain by installing the `langchain-legacy` package (will be released closer to official v1.0 launch date).

2. Standard content blocks: Model APIs evolved from returning messages with a simple content string to more complex output types - reasoning blocks, citations, server-side tool calls, etc. LangChain evolved its message formats to standardize these across providers.

</Card>

*/}
